home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / share / screen-resolution-extra / screenresolution-mechanism.py < prev    next >
Encoding:
Python Source  |  2009-04-06  |  12.6 KB  |  365 lines
  1. #!/usr/bin/python
  2. # -*- coding: utf-8 -*-
  3. #
  4. # Copyright (C) 2008 Fluendo Embedded S.L. (www.fluendo.com)
  5. #
  6. # This program is free software; you can redistribute it and/or modify it under
  7. # the terms of the GNU General Public License as published by the Free Software
  8. # Foundation; either version 2 of the License, or (at your option) any later
  9. # version.
  10. #
  11. # This program is distributed in the hope that it will be useful, but WITHOUT
  12. # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13. # FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14. # details.
  15. #
  16. # You should have received a copy of the GNU General Public License along with
  17. # this program; if not, write to the Free Software Foundation, Inc.,
  18. # 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19. #
  20. # taken from:
  21. # https://code.fluendo.com/remotecontrol/trac/browser/trunk/
  22. #         gnome_lirc_properties/backend.py?rev=217
  23. # 
  24. # modified by Harald Hoyer <harald@redhat.com>
  25. #
  26. # modified by Alberto Milone (tseliot) <albertomilone@alice.it>
  27.  
  28. '''
  29. Processes, which want to access this service have to acquire first
  30. the action id "com.ubuntu.xkit.mechanism.configure" from PolicyKit
  31. '''
  32.  
  33. import dbus, dbus.service, gobject, logging
  34. import os, os.path
  35. import sys
  36. from XKit import xutils, xorgparser
  37. import time
  38. import shutil
  39. import subprocess
  40.  
  41. POLICY_KIT_ACTION     = 'com.ubuntu.screenresolution.mechanism.configure'
  42. class PolicyKitAuthentication(object):
  43.     '''
  44.     Helper class to do authentication via PolicyKit
  45.     '''
  46.     def __init__(self):
  47.         super(PolicyKitAuthentication, self).__init__()
  48.         self.__pk = None
  49.         self.__pa = None
  50.  
  51.     def is_authorized(self, action_id, pid=None):
  52.         '''
  53.         Ask PolicyKit whether we are already authorized.
  54.         '''
  55.  
  56.         # Check whether the process is authorized:
  57.         if pid == None:
  58.             pid = os.getpid()
  59.             
  60.         pid = dbus.UInt32(pid)
  61.         authorized = self.policy_kit.IsProcessAuthorized(action_id, pid, False)
  62.         logging.debug('%s: authorized=%r', action_id, authorized)
  63.  
  64.         return ('yes' == authorized)
  65.  
  66.     def obtain_authorization(self, action_id, widget=None):
  67.         '''
  68.         Try to obtain authoriztation for the specified action.
  69.         '''
  70.         if self.is_authorized(action_id):
  71.             return True
  72.  
  73.         xid = (widget and widget.get_toplevel().window.xid or 0)
  74.         xid, pid = dbus.UInt32(xid), dbus.UInt32(os.getpid())
  75.  
  76.         granted = self.auth_agent.ObtainAuthorization(action_id, xid, pid)
  77.         logging.debug('%s: granted=%r', action_id, granted)
  78.  
  79.         return bool(granted)
  80.  
  81.     def __get_policy_kit(self):
  82.         '''Retreive the D-Bus interface of PolicyKit.'''
  83.  
  84.         if self.__pk:
  85.             return self.__pk
  86.  
  87.         # retreiving the interface raises DBusException on error:
  88.         service = dbus.SystemBus().get_object('org.freedesktop.PolicyKit', '/')
  89.         self.__pk = dbus.Interface(service, 'org.freedesktop.PolicyKit')
  90.         return self.__pk        
  91.  
  92.     def __get_auth_agent(self):
  93.         "Retreive the D-Bus interface of the PolicyKit authentication agent."
  94.  
  95.         if self.__pa:
  96.             return self.__pa
  97.         # retreiving the interface raises DBusException on error:
  98.         self.__pa = dbus.SessionBus().get_object(
  99.             'org.freedesktop.PolicyKit.AuthenticationAgent', '/')
  100.         return self.__pa
  101.  
  102.     auth_agent = property(__get_auth_agent)
  103.     policy_kit = property(__get_policy_kit)
  104.  
  105.  
  106. # Modern flavors of dbus bindings have that symbol in dbus.lowlevel,
  107. # for old flavours the internal _dbus_bindings module must be used.
  108.  
  109. try:
  110.     # pylint: disable-msg=E0611
  111.     from dbus.lowlevel import HANDLER_RESULT_NOT_YET_HANDLED
  112.  
  113. except ImportError:
  114.     from _dbus_bindings import HANDLER_RESULT_NOT_YET_HANDLED
  115.  
  116. class AccessDeniedException(dbus.DBusException):
  117.     '''This exception is raised when some operation is not permitted.'''
  118.  
  119.     _dbus_error_name = 'com.ubuntu.screenresolution.Mechanism.AccessDeniedException'
  120.  
  121. class UnsupportedException(dbus.DBusException):
  122.     '''This exception is raised when some operation is not supported.'''
  123.  
  124.     _dbus_error_name = 'com.ubuntu.screenresolution.Mechanism.UnsupportedException'
  125.  
  126. class UsageError(dbus.DBusException):
  127.     '''This exception is raised when some operation was not used properly.'''
  128.  
  129.     _dbus_error_name = 'com.ubuntu.screenresolution.Mechanism.UsageError'
  130.  
  131. class PolicyKitService(dbus.service.Object):
  132.     '''A D-BUS service that uses PolicyKit for authorization.'''
  133.  
  134.     def _check_permission(self, sender, action=POLICY_KIT_ACTION):
  135.         '''
  136.         Verifies if the specified action is permitted, and raises
  137.         an AccessDeniedException if not.
  138.  
  139.         The caller should use ObtainAuthorization() to get permission.
  140.  
  141.         Needs:
  142.         /usr/bin/polkit-auth --user root --grant org.freedesktop.policykit.read
  143.  
  144.         '''
  145.         if not sender:
  146.             raise AccessDeniedException('Session not authorized by PolicyKit')
  147.  
  148.         try:
  149.             policy_auth = PolicyKitAuthentication()
  150.             bus = dbus.SystemBus()
  151.             dbus_object = bus.get_object('org.freedesktop.DBus', '/')
  152.             dbus_object = dbus.Interface(dbus_object, 'org.freedesktop.DBus')
  153.  
  154.             kit = bus.get_object('org.freedesktop.PolicyKit', '/')
  155.             kit = dbus.Interface(kit, 'org.freedesktop.PolicyKit')
  156.             pid = dbus.UInt32(dbus_object.GetConnectionUnixProcessID(sender))
  157.  
  158.             granted = policy_auth.is_authorized(action, pid)
  159.             logging.info('process authorization: %r', granted)
  160.             print >> sys.stderr,  'process authorization: %r' % granted
  161.  
  162.             if not granted:
  163.                 raise AccessDeniedException('Process not authorized'
  164.                                             ' by PolicyKit')
  165.  
  166.             granted = policy_auth.policy_kit.IsSystemBusNameAuthorized(action,
  167.                                                                        sender,
  168.                                                                        False)
  169.             logging.info('authorization of system bus name: %r', granted)
  170.  
  171.             if 'yes' != granted:
  172.                 raise AccessDeniedException('Session not '
  173.                                             'authorized by PolicyKit')
  174.  
  175.         except AccessDeniedException:
  176.             logging.info("AccessDeniedException")
  177.             raise
  178.  
  179.         except dbus.DBusException, ex:
  180.             logging.info("AccessDeniedException %r",  ex)
  181.             raise AccessDeniedException(ex.message)
  182.  
  183. class BackendService(PolicyKitService):
  184.     '''A D-Bus service that PolicyKit controls access to.'''
  185.  
  186.     # pylint: disable-msg=C0103,E0602
  187.  
  188.     INTERFACE_NAME = 'com.ubuntu.ScreenResolution.Mechanism'
  189.     SERVICE_NAME   = 'com.ubuntu.ScreenResolution.Mechanism'
  190.     IDLE_TIMEOUT   =  30
  191.  
  192.     def __init__(self, connection=None, path='/'):        
  193.         if connection is None:
  194.             connection = get_service_bus()
  195.  
  196.         super(BackendService, self).__init__(connection, path)
  197.  
  198.         self.__name = dbus.service.BusName(self.SERVICE_NAME, connection)
  199.         self.__loop = gobject.MainLoop()
  200.         self.__timeout = 0
  201.         connection.add_message_filter(self.__message_filter)
  202.  
  203.     def __message_filter(self, connection, message):
  204.         '''
  205.         D-BUS message filter that keeps the service alive,
  206.         as long as it receives message.
  207.         '''
  208.  
  209.         if self.__timeout:
  210.             self.__start_idle_timeout()
  211.  
  212.         return HANDLER_RESULT_NOT_YET_HANDLED
  213.  
  214.     def __start_idle_timeout(self):
  215.         '''Restarts the timeout for terminating the service when idle.'''
  216.  
  217.         if self.__timeout:
  218.             gobject.source_remove(self.__timeout)
  219.  
  220.         self.__timeout = gobject.timeout_add(self.IDLE_TIMEOUT * 1000,
  221.                                              self.__timeout_cb)
  222.  
  223.     def __timeout_cb(self):
  224.         '''Timeout callback that terminates the service when idle.'''
  225.  
  226.         # Keep service alive, as long as additional objects are exported:
  227.         if self.connection.list_exported_child_objects('/'):
  228.             return True
  229.  
  230.         print 'Terminating %s due to inactivity.' % self.SERVICE_NAME
  231.         self.__loop.quit()
  232.  
  233.         return False
  234.  
  235.     def run(self):
  236.         '''Creates a GLib main loop for keeping the service alive.'''
  237.  
  238.         print 'Running %s.' % self.SERVICE_NAME
  239.         print ('Terminating it after %d seconds of inactivity.' 
  240.                % self.IDLE_TIMEOUT)
  241.  
  242.         self.__start_idle_timeout()
  243.         self.__loop.run()
  244.  
  245.  
  246.     # pylint: disable-msg=R0913
  247.     @dbus.service.method(dbus_interface=INTERFACE_NAME,
  248.                          in_signature='as', out_signature='b',
  249.                          sender_keyword='sender')   
  250.     def setVirtual(self, virtres, sender=None):
  251.         '''
  252.         Replace the first line of this example with a source and a destination file
  253.         '''
  254.         virtual = ' '.join(virtres)
  255.         
  256.         source = '/etc/X11/xorg.conf'
  257.         destination = '/etc/X11/xorg.conf'
  258.         
  259.         if os.path.exists(source):
  260.             #make a backup of the xorg.conf
  261.             backup = source + "." + time.strftime("%Y%m%d%H%M%S")
  262.             shutil.copyfile(source, backup)
  263.         
  264.         try:
  265.             a = xutils.XUtils(source)
  266.         except(IOError, xorgparser.ParseException):#if xorg.conf is missing or broken
  267.             a = xutils.XUtils()#start from scratch
  268.         
  269.         empty = True
  270.         for section in a.globaldict:
  271.             if len(a.globaldict[section]) > 0:
  272.                 empty = False
  273.                 break
  274.  
  275.         if empty:
  276.             a.makeSection('Device', 'Configured Video Device')
  277.             a.makeSection('Screen', identifier='Configured Screen Device')
  278.             a.addReference('Screen', 'Device', 'Configured Video Device', position=0)
  279.             a.makeSubSection('Screen', 'Display', position=0)
  280.             a.addSubOption('Screen', 'Display', 'Virtual', value=virtual, position=0)
  281.         
  282.         else:#if xorg.conf exists and is not empty
  283.             devicelen = len(a.globaldict['Device'])
  284.             screenlen = len(a.globaldict['Screen'])
  285.             
  286.             if screenlen == 0:
  287.                 screen = a.makeSection('Screen', identifier='Configured Screen Device')
  288.                 if devicelen == 0:
  289.                     device = a.makeSection('Device', 'Configured Video Device')
  290.                 else:
  291.                     device = 0
  292.                 a.addReference('Screen', 'Device', 'Configured Video Device', position=device)
  293.                 
  294.                 a.makeSubSection('Screen', 'Display', position=0)
  295.                 a.addSubOption('Screen', 'Display', 'Virtual', value=virtual, position=0)
  296.                 
  297.             else:#if at least 1 Screen section exists
  298.                 '''
  299.                 Set the virtual section in all the Screen sections
  300.                 '''
  301.                 for screen in a.globaldict['Screen']:
  302.                     a.makeSubSection('Screen', 'Display', position=screen)
  303.                     a.addSubOption('Screen', 'Display', 'Virtual', value=virtual, position=screen)
  304.  
  305.         '''
  306.         Write the changes to the destination file
  307.         '''
  308.         a.writeFile(destination)
  309.         return True
  310.     
  311.     @dbus.service.method(dbus_interface=INTERFACE_NAME,
  312.                          in_signature='s', out_signature='i',
  313.                          sender_keyword='sender')   
  314.     def setDontZap(self, enable, sender=None):
  315.         '''Try to set the DontZap option in the xorg.conf
  316.            and return the exit code of dontzap'''
  317.         dontzap_file = '/usr/bin/dontzap'
  318.         if not os.path.isfile(dontzap_file):
  319.             logging.error('/usr/bin/dontzap does not exist')
  320.             return 1
  321.         
  322.         if enable in ['--enable', '--disable']:
  323.             logging.debug('calling dontzap with %s' % enable)
  324.             retcode = subprocess.call([dontzap_file, enable])
  325.             return retcode
  326.         else:
  327.             logging.error('called with wrong arguments = %s' % enable)
  328.             return 1
  329.     
  330.     
  331. def get_service_bus():
  332.     '''Retrieves a reference to the D-BUS system bus.'''
  333.  
  334.     return dbus.SystemBus()
  335.  
  336. def get_service(bus=None):
  337.     '''Retrieves a reference to the D-BUS driven configuration service.'''
  338.  
  339.     if not bus:
  340.         bus = get_service_bus()
  341.  
  342.     service = bus.get_object(BackendService.SERVICE_NAME, '/')
  343.     service = dbus.Interface(service, BackendService.INTERFACE_NAME)
  344.  
  345.     return service
  346.  
  347. if __name__ == '__main__':
  348.     # Support full tracing when --debug switch is passed:
  349.     import sys
  350.     from sys import argv
  351.  
  352.     # Integrate DBus with GLib main loops.
  353.  
  354.     from dbus.mainloop.glib import DBusGMainLoop
  355.     DBusGMainLoop(set_as_default=True)
  356.  
  357.     # Run the service.
  358.  
  359.     if '--debug' in argv or '-d' in argv:
  360.         logging.basicConfig(stream=sys.stderr)
  361.         logging.getLogger().setLevel(logging.NOTSET)
  362.         
  363.     BackendService().run()
  364.  
  365.